// #include <stdlib.h>
// #include <string.h>
// #include "freertos/FreeRTOS.h"
// #include "freertos/task.h"
// #include "esp_system.h"
// #include "esp_mac.h"
// #include "esp_wifi.h"
// #include "esp_log.h"

// static void connectCallback(void *arg);
// static void receiveDataCallback(void *arg, char *pData, unsigned short len);
// static void disconnectCallback(void *arg);
// static bool checkDataIntegrity(char *pRecvData, uint16_t recvDatalen);
// static void parseUrl(char *pRecvData, UrlFrame_t *pUrlFrame);
// static void findRequestData(char *pRecvData, char *pRequestData);
// static void handleGetUrlPath(UrlFrame_t *pUrlFrame, char *pRequestData);
// static void handlePostUrlPath(UrlFrame_t *pUrlFrame, char *pRequestData);
// static void configWifi(char *pRequestData);
// static void sendPostResponse(bool responseOk, char *pResponseData);
// static void jsonPackageResponseData(bool responseOk, char *pSendData);

// /*********************************************************************
//  * LOCAL VARIABLES
//  */
// static struct espconn s_httpSvrTcpEspconn;											// HTTP服务器TCP连接结构体

// /*********************************************************************
//  * PUBLIC FUNCTIONS
//  */

// /**
//  @brief HTTP服务器初始化
//  @param 无
//  @return 无
// */
// void HttpServerInit(void)
// {
// 	s_httpSvrTcpEspconn.type = ESPCONN_TCP;
// 	s_httpSvrTcpEspconn.state = ESPCONN_NONE;
// 	s_httpSvrTcpEspconn.proto.tcp = (esp_tcp *) os_zalloc(sizeof(esp_tcp));
// 	s_httpSvrTcpEspconn.proto.tcp->local_port = 80;
//     espconn_regist_connectcb(&s_httpSvrTcpEspconn, connectCallback);

//     espconn_accept(&s_httpSvrTcpEspconn);
// }

// /**
//  @brief 监听HTTP服务器
//  @param 无
//  @return 无
// */
// void HttpServerListen(void)
// {
//     espconn_accept(&s_httpSvrTcpEspconn);
// }

// /*********************************************************************
//  * LOCAL FUNCTIONS
//  */

// /**
//  @brief 连接成功的回调函数
//  @param arg -[in] 指向传递给这个回调函数来使用的参数
//  @return 无
// */
// static void connectCallback(void *arg)
// {
//     struct espconn *pEspconn = arg;

//     espconn_regist_recvcb(pEspconn, receiveDataCallback);
//     espconn_regist_disconcb(pEspconn, disconnectCallback);
// }

// /**
//  @brief 接收数据的回调函数
//  @param arg -[in] 指向传递给这个回调函数来使用的参数
//  @param pData -[in] 接收的数据
//  @param len -[in] 接收的数据长度
//  @return 无
// */
// static void receiveDataCallback(void *arg, char *pData, unsigned short len)
// {
// 	if(checkDataIntegrity(pData, len) == false)
// 	{
// 		return ;
// 	}
// 	os_printf("recvData:  %s\n", pData);

// 	UrlFrame_t urlFrame;
// 	char requestData[REQUEST_DATA_SIZE] = {0};

// 	findRequestData(pData, requestData);
// 	parseUrl(pData, &urlFrame);

// 	switch(urlFrame.type)
// 	{
// 	case GET:
// 		os_printf("We have a GET request.\n");
// 		handleGetUrlPath(&urlFrame, requestData);
// 		break;
// 	case POST:
// 		os_printf("We have a POST request.\n");
// 		handlePostUrlPath(&urlFrame, requestData);
// 		break;
// 	default:
// 		break;
// 	}
// }

// /**
//  @brief 断连的回调函数
//  @param arg -[in] 指向传递给这个回调函数来使用的参数
//  @return 无
// */
// static void disconnectCallback(void *arg)
// {
// 	struct espconn *pEspconn = arg;

//     os_printf("httpserver's %d.%d.%d.%d:%d disconnect\n",
//     			pEspconn->proto.tcp->remote_ip[0], pEspconn->proto.tcp->remote_ip[1],
// 				pEspconn->proto.tcp->remote_ip[2], pEspconn->proto.tcp->remote_ip[3],
// 				pEspconn->proto.tcp->remote_port);
// }

// /**
//  @brief 检查数据完整性
//  @param pRecvData -[in] 接收的数据
//  @param recvDatalen -[in] 接收的数据长度
//  @return 1 - 数据完整；0 - 数据缺失
// */
// static bool checkDataIntegrity(char *pRecvData, uint16_t recvDatalen)
// {
// 	if(!pRecvData)
// 	{
// 		return false;
// 	}

//     char lenBuffer[10] = {0};
//     char *pTemp = NULL;
//     char *pData = NULL;
//     char *pTempRecvData;
//     uint16_t tempLen = recvDatalen;
//     uint32_t tempTotalLen = 0;
//     uint32_t dataSumLen = 0;

//     pTemp = (char *) os_strstr(pRecvData, "\r\n\r\n");

//     if(pTemp != NULL)
//     {
//     	tempLen -= pTemp - pRecvData;
//     	tempLen -= 4;
//     	tempTotalLen += tempLen;

//         pData = (char *) os_strstr(pRecvData, "Content-Length: ");

//         if(pData != NULL)
//         {
//             pData += 16;
//             pTempRecvData = (char *) os_strstr(pData, "\r\n");

//             if(pTempRecvData != NULL)
//             {
//                 os_memcpy(lenBuffer, pData, pTempRecvData - pData);
//                 dataSumLen = atoi(lenBuffer);
//                 os_printf("A_dat:%u,total:%u,lenght:%u\n",dataSumLen, tempTotalLen, tempLen);

//                 if(dataSumLen != tempTotalLen)
//                 {
//                     return false;
//                 }

//                 return true;
//             }
//         }
//         else
//         {
//         	return true;
//         }
//     }

//     return false;
// }

// /**
//  @brief 解析URL
//  @param pRecvData -[in] 接收的数据
//  @param pUrlFrame -[in&out] URL框架
//  @return 无
// */
// static void parseUrl(char *pRecvData, UrlFrame_t *pUrlFrame)
// {
// 	if(pUrlFrame == NULL || pRecvData == NULL)
// 	{
// 		return ;
// 	}

// 	char *pStr = NULL;
// 	uint8_t length = 0;
// 	char *pBuffer = NULL;
// 	char *pBuf = NULL;

// 	pBuffer = (char *) os_strstr(pRecvData, "Host:");

// 	if(pBuffer != NULL)
// 	{
// 		length = pBuffer - pRecvData;
// 		pBuf = (char *)os_zalloc(length + 1);
// 		pBuffer = pBuf;
// 		os_memcpy(pBuffer, pRecvData, length);
// 		os_memset(pUrlFrame->select, 0, URL_SIZE);
// 		os_memset(pUrlFrame->command, 0, URL_SIZE);
// 		os_memset(pUrlFrame->filename, 0, URL_SIZE);

// 		if(os_strncmp(pBuffer, "GET ", 4) == 0)
// 		{
// 			pUrlFrame->type = GET;
// 			pBuffer += 4;
// 		}
// 		else if(os_strncmp(pBuffer, "POST ", 5) == 0)
// 		{
// 			pUrlFrame->type = POST;
// 			pBuffer += 5;
// 		}

// 		pBuffer++;
// 		pStr = (char *) os_strstr(pBuffer, "?");

// 		if(pStr != NULL)
// 		{
// 			length = pStr - pBuffer;
// 			os_memcpy(pUrlFrame->select, pBuffer, length);
// 			pStr++;
// 			pBuffer = (char *) os_strstr(pStr, "=");

// 			if(pBuffer != NULL)
// 			{
// 				length = pBuffer - pStr;
// 				os_memcpy(pUrlFrame->command, pStr, length);
// 				pBuffer++;
// 				pStr = (char *) os_strstr(pBuffer, "&");

// 				if(pStr != NULL)
// 				{
// 					length = pStr - pBuffer;
// 					os_memcpy(pUrlFrame->filename, pBuffer, length);
// 				}
// 				else
// 				{
// 					pStr = (char *) os_strstr(pBuffer, " HTTP");

// 					if(pStr != NULL)
// 					{
// 						length = pStr - pBuffer;
// 						os_memcpy(pUrlFrame->filename, pBuffer, length);
// 					}
// 				}
// 			}
// 		}

// 		os_free(pBuf);
// 	}
// }

// /**
//  @brief 查找请求数据
//  @param pRecvData -[in] 接收的数据
//  @param pRequestData -[in&out] 请求的数据
//  @return 无
// */
// static void findRequestData(char *pRecvData, char *pRequestData)
// {
// 	char *pRequestDataStart = NULL;
// 	char *pRequestDataEnd = NULL;

// 	pRequestDataStart = strchr(pRecvData, '{');
// 	if(pRequestDataStart != NULL)
// 	{
// 		pRequestDataEnd = strrchr(pRecvData, '}');
// 		if(pRequestDataEnd != NULL)
// 		{
// 			os_memcpy(pRequestData, pRequestDataStart, pRequestDataEnd - pRequestDataStart + 1);
// 		}
// 	}

// 	pRequestData[pRequestDataEnd - pRequestDataStart + 1] = '\0';
// }

// /**
//  @brief 处理GET请求URL路径
//  @param pUrlFrame -[in] URL框架
//  @param pRequestData -[in] 请求的数据
//  @return 无
// */
// static void handleGetUrlPath(UrlFrame_t *pUrlFrame, char *pRequestData)
// {
//     os_printf("Type:%d, Select:%s, Command:%s, Filename:%s ",
// 	pUrlFrame->type, pUrlFrame->select, pUrlFrame->command, pUrlFrame->filename);
// }

// /**
//  @brief 处理POST请求URL路径
//  @param pUrlFrame -[in] URL框架
//  @param pRequestData -[in] 请求的数据
//  @return 无
// */
// static void handlePostUrlPath(UrlFrame_t *pUrlFrame, char *pRequestData)
// {
//     os_printf("Type:%d, Select:%s, Command:%s, Filename:%s ",
// 	pUrlFrame->type, pUrlFrame->select, pUrlFrame->command, pUrlFrame->filename);

// 	if(os_strcmp(pUrlFrame->select, "config") == 0)
// 	{
// 		if(os_strcmp(pUrlFrame->command, "command") == 0)
// 		{
// 			if(os_strcmp(pUrlFrame->filename, "wifi") == 0)
// 			{
// 				configWifi(pRequestData);
// 			}
// 		}
// 	}
// }

// /**
//  @brief 配置WIFI接口
//  @param pRequestData -[in] 请求的数据
//  @return 无
// */
// static void configWifi(char *pRequestData)
// {
// 	if(!pRequestData)
// 	{
// 		return ;
// 	}

// 	cJSON *pRoot = cJSON_Parse(pRequestData);
// 	if(!pRoot)
// 	{
// 		return ;
// 	}

// 	char sendData[RESPONSE_DATA_SIZE] = {0};
// 	cJSON *pRequest = cJSON_GetObjectItem(pRoot, "request");      					// 解析request字段内容
// 	if(!pRequest)
// 	{
// 		os_sprintf(sendData, "%s", "No request Item");
// 		sendPostResponse(false, sendData);
// 		cJSON_Delete(pRoot);
// 		return ;
// 	}

// 	cJSON *pStation = cJSON_GetObjectItem(pRequest, "station");         			// 解析request子节点station字段内容字段内容
// 	if(pStation)
// 	{
// 		char ssid[32] = {0};
// 		char password[64] = {0};
// 		cJSON *pSsid = cJSON_GetObjectItem(pStation, "ssid");
// 		cJSON *pPassword = cJSON_GetObjectItem(pStation, "password");
// 		if(!pSsid)
// 		{
// 			os_sprintf(sendData, "%s", "No ssid Item");
// 			sendPostResponse(false, sendData);
// 			cJSON_Delete(pRoot);
// 			return ;
// 		}
// 		if(!pPassword)
// 		{
// 			os_sprintf(sendData, "%s", "No password Item");
// 			sendPostResponse(false, sendData);
// 			cJSON_Delete(pRoot);
// 			return ;
// 		}

// 		os_strcpy(ssid, pSsid->valuestring);
// 		os_strcpy(password, pPassword->valuestring);

// 		os_sprintf(sendData, "%s", "Config station succeed");
// 		sendPostResponse(true, sendData);

// 		ConfigStationMode(ssid, password);

// 		UdpSendDeviceInfo();														// UDP发送设备信息
// 	}
// 	else
// 	{
// 		os_sprintf(sendData, "%s", "No station Item");
// 		sendPostResponse(false, sendData);
// 	}

// 	cJSON_Delete(pRoot);
// }

// /**
//  @brief 发送POST请求的HTTP响应
//  @param responseOk -[in] 响应是否成功
//  @param pResponseData -[in] 响应数据
//  @return 无
// */
// static void sendPostResponse(bool responseOk, char *pResponseData)
// {
//     char sendData[RESPONSE_DATA_SIZE] = {0};
//     char responseCode[15] = {0};

//     jsonPackageResponseData(responseOk, pResponseData);

// 	if(responseOk)
//     {
// 		os_sprintf(responseCode, "200 OK", os_strlen(responseCode));
//     }
// 	else
// 	{
// 		os_sprintf(responseCode, "400 BadRequest", os_strlen(responseCode));
// 	}

// 	os_sprintf(sendData, HTTP_SERVER_RESPONSE_FRAME, responseCode, os_strlen(pResponseData), pResponseData);

// 	espconn_sent(&s_httpSvrTcpEspconn, sendData, os_strlen(sendData));
// }

// /**
//  @brief JSON格式封装响应数据
//  @param responseOk -[in] 响应是否成功
//  @param pSendData -[in&out] 要封装的发送数据
//  @return 无
// */
// static void jsonPackageResponseData(bool responseOk, char *pSendData)
// {
// 	if(!pSendData)
// 	{
// 		return ;
// 	}

// 	cJSON *pRoot = cJSON_CreateObject();

// 	uint16 statusCode;

// 	if(responseOk)
// 	{
// 		statusCode = 200;
// 	}
// 	else
// 	{
// 		statusCode = 400;
// 	}

// 	cJSON_AddNumberToObject(pRoot, "status", statusCode);
// 	cJSON_AddStringToObject(pRoot, "message", pSendData);
// 	char *tempBuffer = cJSON_Print(pRoot);
// 	os_sprintf(pSendData, "%s", tempBuffer);

// 	os_free((void *) tempBuffer);
// 	cJSON_Delete(pRoot);
// }
